Lock相关笔记

.NET 9使用System.Threading.Lock简化线程同步

注：文章部分内容来自于这篇博客

微软相关文档：Lock.EnterScope 方法

场景 1：多线程计数器的线程安全操作

using System;
using System.Threading;
using System.Threading.Tasks;
namespace CSharp13App
{
    class Program
    {
        private static Lock _lock = new Lock();
        private static int _counter = 0;
        static async Task Main(string[] args)
        {
            Console.WriteLine("多线程计数器示例开始...");
            // 启动多个并发任务
            Task[] tasks = new Task[10];
            for (int i = 0; i < 10; i++)
            {
                tasks[i] = Task.Run(() => IncrementCounter());
            }
            // 等待所有任务完成
            await Task.WhenAll(tasks);

            Console.WriteLine($"计数器最终值: {_counter}");
        }

        static void IncrementCounter()
        {
            using (_lock.EnterScope())
            {
                Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在递增计数器...");
                int temp = _counter;
                Thread.Sleep(100); // 模拟复杂操作
                _counter = temp + 1;
                Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 更新后的计数器值: {_counter}");
            }
        }
    }
}

场景 2：保护共享队列的线程安全操作

using System;
using System.Threading;
using System.Threading.Tasks;

namespace CSharp13App
{
    class Program
    {
        private static Lock _queueLock = new Lock();
        private static Queue<int> _queue = new Queue<int>();
        static async Task Main(string[] args)
        {
            Task producer = Task.Run(() => Producer());
            Task consumer = Task.Run(() => Consumer());

            await Task.WhenAll(producer, consumer);
        }
        static void Producer()
        {
            for (int i = 0; i < 10; i++)
            {
                using (_queueLock.EnterScope())
                {
                    _queue.Enqueue(i);
                    Console.WriteLine($"生产者添加: {i}");
                }
                Thread.Sleep(200); // 模拟生产延迟
            }
        }
        static void Consumer()
        {
            for (int i = 0; i < 10; i++)
            {
                int item;
                using (_queueLock.EnterScope())
                {
                    if (_queue.Count > 0)
                    {
                        item = _queue.Dequeue();
                        Console.WriteLine($"消费者取出: {item}");
                    }
                    else
                    {
                        Console.WriteLine("队列为空，等待中...");
                        continue;
                    }
                }
                Thread.Sleep(300); // 模拟消费延迟
            }
        }
    }
}

场景 3：异步代码中的线程同步

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    private static Lock _lock = new Lock();
    private static int _sharedResource = 0;

    static async Task Main(string[] args)
    {
        Task[] tasks = new Task[5];
        for (int i = 0; i < 5; i++)
        {
            tasks[i] = PerformAsyncTask(i);
        }

        await Task.WhenAll(tasks);
        Console.WriteLine($"共享资源最终值: {_sharedResource}");
    }
    
    static async Task PerformAsyncTask(int taskId)
    {
        // 在加锁范围内操作共享资源
        int temp;
        using (_lock.EnterScope())
        {
            Console.WriteLine($"任务 {taskId} 正在访问共享资源...");
            temp = _sharedResource + 1; // 加锁范围内完成操作
        }
        // 在加锁范围外进行异步操作
        await Task.Delay(500); // 模拟异步操作
        using (_lock.EnterScope())
        {
            _sharedResource = temp; // 再次进入锁更新共享资源
            Console.WriteLine($"任务 {taskId} 完成，更新共享资源为: {_sharedResource}");
        }
    }
    // 这样写会出现编译错误
    //static async Task PerformAsyncTask(int taskId)
    //{
    //    using (_lock.EnterScope())
    //    {
    //        Console.WriteLine($"任务 {taskId} 正在访问共享资源...");
    //        int temp = _sharedResource;
    //        await Task.Delay(500); // 模拟异步操作
    //        _sharedResource = temp + 1;
    //        Console.WriteLine($"任务 {taskId} 完成，更新共享资源为: {_sharedResource}");
        }
    }
}